// Copyright (C) 2016 Petar Perisin <petar.perisin@gmail.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

#include "ansiescapecodehandler.h"

// #include "qtcassert.h"

#include <QPlainTextEdit>

namespace Utils {

static const QString s_escape        = "\x1b[";
static const QChar s_semicolon       = ';';
static const QChar s_colorTerminator = 'm';

/*!
    \class Utils::AnsiEscapeCodeHandler
    \inmodule QtCreator

    \brief The AnsiEscapeCodeHandler class parses text and extracts ANSI escape codes from it.

    In order to preserve color information across text segments, an instance of this class
    must be stored for the lifetime of a stream.
    Also, one instance of this class should not handle multiple streams (at least not
    at the same time).

    Its main function is parseText(), which accepts text and default QTextCharFormat.
    This function is designed to parse text and split colored text to smaller strings,
    with their appropriate formatting information set inside QTextCharFormat.

    Usage:
    \list
    \li Create new instance of AnsiEscapeCodeHandler for a stream.
    \li To add new text, call parseText() with the text and a default QTextCharFormat.
        The result of this function is a list of strings with formats set in appropriate
        QTextCharFormat.
    \endlist
*/

static QColor ansiColor(uint code)
{
    // QTC_ASSERT(code < 8, return QColor());

    if (code >= 8) {
        return QColor();
    }

    const int red   = code & 1 ? 170 : 0;
    const int green = code & 2 ? 170 : 0;
    const int blue  = code & 4 ? 170 : 0;
    return QColor(red, green, blue);
}

QList<FormattedText> AnsiEscapeCodeHandler::parseText(const FormattedText &input)
{
    enum AnsiEscapeCodes {
        ResetFormat            =  0,
        BoldText               =  1,
        TextColorStart         = 30,
        TextColorEnd           = 37,
        RgbTextColor           = 38,
        DefaultTextColor       = 39,
        BackgroundColorStart   = 40,
        BackgroundColorEnd     = 47,
        RgbBackgroundColor     = 48,
        DefaultBackgroundColor = 49
    };

    const QChar eraseToEol      = 'K';

    QList<FormattedText> outputData;
    QTextCharFormat charFormat = m_previousFormatClosed ? input.format : m_previousFormat;
    QString strippedText;
    if (m_pendingText.isEmpty()) {
        strippedText = input.text;
    } else {
        strippedText = m_pendingText.append(input.text);
        m_pendingText.clear();
    }

    while (!strippedText.isEmpty()) {
        // QTC_ASSERT(m_pendingText.isEmpty(), break);

        if (!m_pendingText.isEmpty()) {
            break;
        }

        if (m_waitingForTerminator) {
            // We ignore all escape codes taking string arguments.
            QString terminator = "\x1b\\";
            int terminatorPos = strippedText.indexOf(terminator);
            if (terminatorPos == -1 && !m_alternateTerminator.isEmpty()) {
                terminator = m_alternateTerminator;
                terminatorPos = strippedText.indexOf(terminator);
            }
            if (terminatorPos == -1) {
                m_pendingText = strippedText;
                break;
            }
            m_waitingForTerminator = false;
            m_alternateTerminator.clear();
            strippedText.remove(0, terminatorPos + terminator.length());
            if (strippedText.isEmpty())
                break;
        }
        const int escapePos = strippedText.indexOf(s_escape.at(0));
        if (escapePos < 0) {
            outputData << FormattedText(strippedText, charFormat);
            break;
        } else if (escapePos != 0) {
            // 把 ANSI转义字符
            outputData << FormattedText(strippedText.left(escapePos), charFormat);
            strippedText.remove(0, escapePos);
        }
        // static const QString s_escape = "\x1b[";
        // if (strippedText.at(0) != s_escape.at(0)) break;
        // QTC_ASSERT(strippedText.at(0) == s_escape.at(0), break);
        if (strippedText.at(0) != s_escape.at(0)) {
            break;
        }

        while (!strippedText.isEmpty() && s_escape.at(0) == strippedText.at(0)) {
            // 保证了多个字符串连续传入
            if (s_escape.startsWith(strippedText)) {
                // control secquence is not complete
                m_pendingText += strippedText;
                strippedText.clear();
                break;
            }
            // 如果不符合ansi序列， 这里感觉没有考虑到 strippedText的length
            if (!strippedText.startsWith(s_escape)) {
                switch (strippedText.at(1).toLatin1()) {
                case '\\': // Unexpected terminator sequence.
                    // QTC_CHECK(false);
                    Q_FALLTHROUGH();
                case 'N': case 'O': // Ignore unsupported single-character sequences.
                    strippedText.remove(0, 2);
                    break;
                case ']':
                    m_alternateTerminator = QChar(7);
                    Q_FALLTHROUGH();
                case 'P':  case 'X': case '^': case '_':
                    strippedText.remove(0, 2);
                    m_waitingForTerminator = true;
                    break;
                default:
                    // not a control sequence
                    m_pendingText.clear();
                    outputData << FormattedText(strippedText.left(1), charFormat);
                    strippedText.remove(0, 1);
                    continue;
                }
                break;
            }
            // 将剩余的text放入pendingText，并 remove
            m_pendingText += strippedText.mid(0, s_escape.length());
            strippedText.remove(0, s_escape.length());

            // \e[K is not supported. Just strip it.
            // const QChar eraseToEol      = 'K';
            if (strippedText.startsWith(eraseToEol)) {
                m_pendingText.clear();
                strippedText.remove(0, 1);
                continue;
            }

            // get the number
            QString strNumber;
            QStringList numbers;
            while (!strippedText.isEmpty()) {
                if (strippedText.at(0).isDigit()) {
                    strNumber += strippedText.at(0);
                } else {
                    if (!strNumber.isEmpty())
                        numbers << strNumber;
                    // static const QChar s_semicolon       = ';';
                    if (strNumber.isEmpty() || strippedText.at(0) != s_semicolon)
                        // 例如 \x1B[01;34m, 遇到m的时候就break出去了
                        break;
                    strNumber.clear();
                }
                // 将字符放进pendingText，并移除
                m_pendingText += strippedText.mid(0, 1);
                strippedText.remove(0, 1);
            }

            if (strippedText.isEmpty())
                break;

            // remove terminating char
            // 删除终止字符
            // static const QChar s_colorTerminator = 'm';
            if (!strippedText.startsWith(s_colorTerminator)) {
                // 不是颜色字符，删掉pendingText里面的内容
                m_pendingText.clear();
                strippedText.remove(0, 1);
                break;
            }
            // got consistent control sequence, ok to clear pending text
            m_pendingText.clear();
            strippedText.remove(0, 1);

            if (numbers.isEmpty()) {
                // QTextCharFormat
                charFormat = input.format;
                // m_previousFormatClosed = true;
                endFormatScope();
            }

            // 处理ANSI颜色转义字符
            for (int i = 0; i < numbers.size(); ++i) {
                const uint code = numbers.at(i).toUInt();

                if (code >= TextColorStart && code <= TextColorEnd) {
                    // 30–37	Set text colour from the basic colour palette of 0–7 【从0-7的基本颜色板中设置文本颜色,即前景色】
                    // 根据转移字符设置前景色
                    charFormat.setForeground(ansiColor(code - TextColorStart));
                    setFormatScope(charFormat);
                } else if (code >= BackgroundColorStart && code <= BackgroundColorEnd) {
                    // 40–47	Set background colour 【从0-7的基本颜色板中设置背景色】
                    // 根据转移字符设置背景色
                    charFormat.setBackground(ansiColor(code - BackgroundColorStart));
                    setFormatScope(charFormat);
                } else {
                    switch (code) {
                    case ResetFormat:
                        // 重置：关闭所有属性 
                        charFormat = input.format;
                        endFormatScope();
                        break;
                    case BoldText:
                        // 设置字体为粗体
                        charFormat.setFontWeight(QFont::Bold);
                        setFormatScope(charFormat);
                        break;
                    case DefaultTextColor:
                        // 默认字体前景色
                        charFormat.setForeground(input.format.foreground());
                        setFormatScope(charFormat);
                        break;
                    case DefaultBackgroundColor:
                        // 默认字体背景色
                        charFormat.setBackground(input.format.background());
                        setFormatScope(charFormat);
                        break;
                    case RgbTextColor:
                    case RgbBackgroundColor:
                        // See http://en.wikipedia.org/wiki/ANSI_escape_code#Colors
                        if (++i >= numbers.size())
                            break;
                        switch (numbers.at(i).toInt()) {
                        case 2:
                            // RGB set with format: 38;2;<r>;<g>;<b>
                            if ((i + 3) < numbers.size()) {
                                (code == RgbTextColor) ?
                                      charFormat.setForeground(QColor(numbers.at(i + 1).toInt(),
                                                                      numbers.at(i + 2).toInt(),
                                                                      numbers.at(i + 3).toInt())) :
                                      charFormat.setBackground(QColor(numbers.at(i + 1).toInt(),
                                                                      numbers.at(i + 2).toInt(),
                                                                      numbers.at(i + 3).toInt()));
                                setFormatScope(charFormat);
                            }
                            i += 3;
                            break;
                        case 5:
                            // 256 color mode with format: 38;5;<i>
                            uint index = numbers.at(i + 1).toUInt();

                            QColor color;
                            if (index < 8) {
                                // The first 8 colors are standard low-intensity ANSI colors.
                                color = ansiColor(index);
                            } else if (index < 16) {
                                // The next 8 colors are standard high-intensity ANSI colors.
                                color = ansiColor(index - 8).lighter(150);
                            } else if (index < 232) {
                                // The next 216 colors are a 6x6x6 RGB cube.
                                uint o = index - 16;
                                // 这里乘以51没搞懂啥意思，变亮一点吗？
                                color = QColor((o / 36) * 51, ((o / 6) % 6) * 51, (o % 6) * 51);
                            } else {
                                // 灰度色
                                // The last 24 colors are a greyscale gradient.
                                int grey = int((index - 232) * 11);
                                color = QColor(grey, grey, grey);
                            }
                            
                            // 根据code类型，将color设置到前景色或者背景色
                            if (code == RgbTextColor)
                                charFormat.setForeground(color);
                            else
                                charFormat.setBackground(color);

                            setFormatScope(charFormat);
                            ++i;
                            break;
                        }
                        break;
                    default:
                        break;
                    }
                }
            }
        }
    }
    return outputData;
}

void AnsiEscapeCodeHandler::endFormatScope()
{
    m_previousFormatClosed = true;
}

void AnsiEscapeCodeHandler::setTextInDocument(QTextDocument *doc, const QString &text)
{
    AnsiEscapeCodeHandler handler;
    const QList<FormattedText> formattedTextList = handler.parseText(FormattedText(text));
    doc->clear();
    QTextCursor cursor(doc);
    cursor.beginEditBlock();
    for (const auto &formattedChunk : formattedTextList)
        cursor.insertText(formattedChunk.text, formattedChunk.format);
    cursor.endEditBlock();
    doc->setModified(false);
}

QString AnsiEscapeCodeHandler::ansiFromColor(const QColor &color)
{
    // RGB color is ESC[38;2;<r>;<g>;<b>m
    // https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit
    return QStringLiteral("%1;2;%2;%3;%4m")
        .arg(s_escape + "38")
        .arg(color.red())
        .arg(color.green())
        .arg(color.blue());
}

QString AnsiEscapeCodeHandler::noColor()
{
    return s_escape + s_colorTerminator;
}

void AnsiEscapeCodeHandler::Reset()
{
    m_previousFormatClosed = true;
    m_waitingForTerminator = false;
    m_alternateTerminator.clear();
    m_previousFormat = QTextCharFormat();
    m_pendingText.clear();
}

void AnsiEscapeCodeHandler::setFormatScope(const QTextCharFormat &charFormat)
{
    m_previousFormat = charFormat;
    m_previousFormatClosed = false;
}

} // namespace Utils
